// 定义产品特质 `Product`，规定了产品的使用方法。
trait Product {
    fn use_product(&self);
}

// 具体产品类型 `ConcreteProductA` 和 `ConcreteProductB`，实现了 `Product` 特质。
struct ConcreteProductA;
struct ConcreteProductB;

impl Product for ConcreteProductA {
    fn use_product(&self) {
        println!("Using ConcreteProductA");
    }
}

impl Product for ConcreteProductB {
    fn use_product(&self) {
        println!("Using ConcreteProductB");
    }
}

// 定义创造者特质 `Creator`，接受一个产品类型参数 `P: Product`，定义了工厂方法和一些操作。
trait Creator<P: Product> {
    fn factory_method(&self) -> P; // 工厂方法，返回一个具体的产品实例。

    fn some_operation(&self) {
        let product = self.factory_method(); // 使用工厂方法创建具体产品。
        product.use_product(); // 调用具体产品的使用方法。
    }
}

// 具体创造者类型 `ConcreteCreatorA` 和 `ConcreteCreatorB`，分别实现了 `Creator` 特质。
struct ConcreteCreatorA;
struct ConcreteCreatorB;

impl Creator<ConcreteProductA> for ConcreteCreatorA {
    fn factory_method(&self) -> ConcreteProductA {
        ConcreteProductA // 实现工厂方法，创建 `ConcreteProductA` 类型的产品。
    }
}

impl Creator<ConcreteProductB> for ConcreteCreatorB {
    fn factory_method(&self) -> ConcreteProductB {
        ConcreteProductB // 实现工厂方法，创建 `ConcreteProductB` 类型的产品。
    }
}

// 主函数入口 `main()`，演示工厂方法模式的使用。
pub fn main() {
    let creator_a = ConcreteCreatorA;
    creator_a.some_operation(); // 调用 `ConcreteCreatorA` 的 `some_operation` 方法。

    let creator_b = ConcreteCreatorB;
    creator_b.some_operation(); // 调用 `ConcreteCreatorB` 的 `some_operation` 方法。
}
